import { KEY } from './config'

// 时间格式处理
export const formatDate = (date, format) => {
  if (/(y+)/.test(format)) {
    format = format.replace(RegExp.$1, (date.getFullYear() + '').substring(4 - RegExp.$1.length))
  }
  let o = {
    'M+': date.getMonth() + 1,
    'd+': date.getDate(),
    'h+': date.getHours(),
    'm+': date.getMinutes(),
    's+': date.getSeconds()
  }
  for (let k in o) {
    let reg = new RegExp(`(${k})`)
    if (reg.test(format)) {
      let str = o[k] + ''
      format = format.replace(RegExp.$1, (RegExp.$1.length === 1) ? str : tool.addZero(str))
    }
  }
  return format
}

// localStorage
export const storage = {
  get(key) {
    return JSON.parse(localStorage.getItem(key))
  },
  set(key, value) {
    localStorage.setItem(key, JSON.stringify(value))
  },
  remove(key) {
    localStorage.removeItem(key)
  },
  clear() {
    localStorage.clear()
  }
}

export const session = {
  get(key) {
    return JSON.parse(sessionStorage.getItem(key))
  },
  set(key, value) {
    sessionStorage.setItem(key, JSON.stringify(value))
  },
  remove(key) {
    sessionStorage.removeItem(key)
  },
  clear() {
    sessionStorage.clear()
  }
}

// cookie操作
export const cookie = {
  get(key) {
    let arr = []
    let reg = new RegExp('(^| )' + key + '=([^;]*)(;|$)')

    // 如果获取到cookie，则直接返回数据
    if (arr = document.cookie.match(reg)) {
      return unescape(arr[2])
    }
    return null;
  },
  set(key, value, time) {
    let Days = 30
    let exp = new Date()
    exp.setTime(exp.getTime() + Days * 24 * 60 * 60 * 1000)
    document.cookie = key + "="+ escape (value) + ";expires=" + exp.toGMTString();
  },
  remove(key) {
    let exp = new Date()
    exp.setTime(exp.getTime() - 1)
    let cval = cookie.get(key)
    if(cval) {
      document.cookie = key + "=" + cval + ";expires="+exp.toGMTString()
    }
  }
}

// 方法
export const tool = {
  addZero(str) {
    str = str.toString()
    return ('00' + str).substring(str.length)
  }
}

// 字符串验证
export const verify = {
  isPhone(value) {
    return /(^1[0-9]{10}$)/.test(value)
  },
  isPassword(value) {
    return  /^\w{6,16}$/.test(value)
  },
  isNull(value) {
    return value.length
  } 
}

/**
 * 将参数追加到url上去
 *
 * @param { String } url    需要追加的url链接
 * @param { Object } params 需要追加的参数
 */
export const joinQueryParamsToUrl = (url = '', params) => {
  // 将之前的参数截取（不要了）
  let urlPrefix = `${url.split('?')[0]}?`
  // 将参数全部获取
  for (let p in params) {
    urlPrefix += `${p}=${params[p]}&`
  }
  return urlPrefix.substr(0, urlPrefix.length - 1)
}

// 给数组添加has方法
export const inArray = (list, data) => {
  // 如果是待判断的值是数组或对象，则将其转成字符串
  if (typeof data == 'object' || typeof data == 'Array') {
    data = JSON.stringify(data)
  }

  // 遍历的对象
  let eachObj = ''

  // 遍历数据
  return list.some((v) => {
    eachObj = v
    
    // 如果值是对象或者是数组
    if (typeof v == 'object' || typeof v == 'Array') {
      eachObj = JSON.stringify(v)
    }

    // 只要有一个值是相等的，则将标志位置为true
    return eachObj == data
  })
}

// 将金额转换成汉字金额
export const convertCurrency = (money) => {
  //汉字的数字
  var cnNums = new Array('零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖')
  //基本单位
  var cnIntRadice = new Array('', '拾', '佰', '仟')
  //对应整数部分扩展单位
  var cnIntUnits = new Array('', '万', '亿', '兆')
  //对应小数部分单位
  var cnDecUnits = new Array('角', '分', '毫', '厘')
  //整数金额时后面跟的字符
  var cnInteger = '整'
  //整型完以后的单位
  var cnIntLast = '元'
  //最大处理的数字
  var maxNum = 999999999999999.9999
  //金额整数部分
  var integerNum
  //金额小数部分
  var decimalNum
  //输出的中文金额字符串
  var chineseStr = ''
  //分离金额后用的数组，预定义
  var parts;
  if (money == '') { return '' }
  money = parseFloat(money)
  if (money >= maxNum) {
    //超出最大处理数字
    return ''
  }
  if (money == 0) {
    chineseStr = cnNums[0] + cnIntLast + cnInteger
    return chineseStr
  }
  //转换为字符串
  money = money.toString()
  if (money.indexOf('.') == -1) {
    integerNum = money
    decimalNum = ''
  } else {
    parts = money.split('.')
    integerNum = parts[0]
    decimalNum = parts[1].substr(0, 4)
  }
  //获取整型部分转换
  if (parseInt(integerNum, 10) > 0) {
    var zeroCount = 0
    var IntLen = integerNum.length
    for (var i = 0; i < IntLen; i++) {
      var n = integerNum.substr(i, 1)
      var p = IntLen - i - 1
      var q = p / 4
      var m = p % 4
      if (n == '0') {
        zeroCount++
      } else {
        if (zeroCount > 0) {
          chineseStr += cnNums[0]
        }
        //归零
        zeroCount = 0
        chineseStr += cnNums[parseInt(n)] + cnIntRadice[m]
      }
      if (m == 0 && zeroCount < 4) {
        chineseStr += cnIntUnits[q]
      }
    }
    chineseStr += cnIntLast
  }
  //小数部分
  if (decimalNum) {
    var decLen = decimalNum.length
    for (var i = 0; i < decLen; i++) {
      var n = decimalNum.substr(i, 1)
      if (n != '0') {
        chineseStr += cnNums[Number(n)] + cnDecUnits[i]
      }
    }
  }
  if (chineseStr == '') {
    chineseStr += cnNums[0] + cnIntLast + cnInteger
  } else if (decimalNum == '') {
    chineseStr += cnInteger
  }
  return chineseStr
}

// 图片的扩展格式
export const imageExt = ['png', 'jpg', 'jpeg', 'gif', 'ico']

// 当前文件是否是图片
export const isImageFile = (file) => {
  // 如果没有文件，则返回false（不是图片）
  if (!file.value) {
    return false
  }

  // 获取文件扩展名
  let fileExts = file.value.split('.')

  // 如果上传的文件没有扩展名
  if (fileExts.length < 2) {
    return false
  }

  // 获取最后一个扩展名
  let fileExt = fileExts[fileExts.length - 1]

  // 返回最后的匹配结果
  return inArray(imageExt, fileExt)
}

/**
 * 获取待上传文件的实体路径
 */
export const getFileRealPath = (fileObj) => {
  // 商品链接
  let src = ''
  let windowURL = window.URL || window.webkitURL

  // 如果是高级别浏览器
  if (fileObj && fileObj.files && fileObj.files[0]) {
    return windowURL.createObjectURL(fileObj.files[0])
  }
  return fileObj.value
}

// 滚动监听
export const wScroll = (callback) => {
  let timer
  function fnScroll() {
    if (timer) {
      clearTimeout(timer)
    }
    timer = setTimeout(() => {
      callback && callback(document.body.scrollTop || document.documentElement.scrollTop)
    }, 10)
  }
  return {
    mount() {
      window.addEventListener('scroll', fnScroll, false)
    },
    unmount() {
      window.removeEventListener('scroll', fnScroll, false)
    }
  }
}

/**
 * 加密
 * @param { String/Object } str 待加密的文字或对象 
 */
export const encrypt = (str) => {
  let prand = ''; 
	for(let i = 0; i < KEY.length; i ++) { 
		prand += KEY.charCodeAt(i).toString(); 
	} 
	let sPos = Math.floor(prand.length / 5); 
	let mult = parseInt(prand.charAt(sPos) + prand.charAt(sPos * 2) + prand.charAt(sPos * 3) + prand.charAt(sPos * 4) + prand.charAt(sPos * 5)); 
	let incr = Math.ceil(KEY.length / 2); 
	let modu = Math.pow(2, 31) - 1; 
	let salt = Math.round(Math.random() * 1000000000) % 100000000; 
	prand += salt; 
	while(prand.length > 10) { 
		prand = (parseInt(prand.substring(0, 10)) + parseInt(prand.substring(10, prand.length))).toString(); 
	} 
	prand = (mult * prand + incr) % modu; 
	let enc_chr = ""; 
	let enc_str = ""; 
	for(let i=0; i<str.length; i++) { 
		enc_chr = parseInt(str.charCodeAt(i) ^ Math.floor((prand / modu) * 255)); 
		if(enc_chr < 16) { 
			enc_str += "0" + enc_chr.toString(16); 
		} else enc_str += enc_chr.toString(16); 
		prand = (mult * prand + incr) % modu; 
	} 
	salt = salt.toString(16); 
	while(salt.length < 8) salt = "0" + salt; 
	enc_str += salt; 
	return enc_str; 
}

/**
 * 解密
 * @param { String/Object } str 待解密的内容
 */
export const decrypt = (str) => {
  let prand = ""; 
	for(let i = 0; i < KEY.length; i++) { 
		prand += KEY.charCodeAt(i).toString(); 
	} 
	let sPos = Math.floor(prand.length / 5); 
	let mult = parseInt(prand.charAt(sPos) + prand.charAt(sPos * 2) + prand.charAt(sPos * 3) + prand.charAt(sPos * 4) + prand.charAt(sPos * 5)); 
	let incr = Math.round(KEY.length / 2); 
	let modu = Math.pow(2, 31) - 1; 
	let salt = parseInt(str.substring(str.length - 8, str.length), 16);
	str = str.substring(0, str.length - 8); 
	prand += salt; 
	while(prand.length > 10) { 
		prand = (parseInt(prand.substring(0, 10)) + parseInt(prand.substring(10, prand.length))).toString(); 
	} 
	prand = (mult * prand + incr) % modu; 
	let enc_chr = ""; 
	let enc_str = ""; 
	for(let i = 0; i < str.length; i += 2) { 
		enc_chr = parseInt(parseInt(str.substring(i, i+2), 16) ^ Math.floor((prand / modu) * 255)); 
		enc_str += String.fromCharCode(enc_chr); 
		prand = (mult * prand + incr) % modu; 
	} 
	return enc_str;
}

/**
 * 将url中的参数转换成当前存储的对象返还给前台
 */
export const parseDecryptParams = (str) => {
  // 如果url中字符串不存在
  if (!str) {
    return
  }
  // 将字符串解密
  let decryptArray = decrypt(str).split(',')
  // 将数据放到缓存中
  session.set('userInfo', {
    accessToken: decryptArray[0],
    userName: decryptArray[1],
    storeId: Number(decryptArray[2])
  })
}